// $ANTLR 3.1.1 cLPMEDIntelliSenseParser.g 2009-02-11 17:08:29
// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162
namespace  CommonClasses.ANTLRGrammars 
{

	using System.Collections.Generic;
	using System.Linq;


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;


using Antlr.Runtime.Tree;

public partial class cLPMEDIntelliSenseParser : Parser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"CPROGRAM", 
		"CDEVICE", 
		"CTYPE", 
		"CBLOCK", 
		"CSTATEMENT", 
		"CIFTE", 
		"CASSIGN", 
		"CWHILE", 
		"CFOR", 
		"CFORDEC", 
		"CUNARMIN", 
		"CMETHODNAME", 
		"CCALL", 
		"CINT", 
		"CFLOAT", 
		"CBOOL", 
		"CSYNCCALL", 
		"CASYNCCALL", 
		"CWAITTHECALL", 
		"CWAITANYCALL", 
		"CENDTHECALL", 
		"OBJECTNAME", 
		"MEMBERNAME", 
		"NODES", 
		"CGETSTATE", 
		"CBREAKPOINT", 
		"CREGMETHACCESS", 
		"CREGFUNCACCESS", 
		"CTERMINATEALL", 
		"CASYNCFUNCCALL", 
		"CSYNCFUNCCALL", 
		"CWAITFUNCFINISH", 
		"CDEFUN", 
		"PARAMS", 
		"PARAM", 
		"TERMINATEALL", 
		"OpIncDec", 
		"OpNegation", 
		"OpUnar", 
		"OpDivMul", 
		"OpAddSub", 
		"OpLogicalA", 
		"OpLogicalB", 
		"OpAnd", 
		"OpOr", 
		"TYPE", 
		"DBOOL", 
		"DEVICE", 
		"STATE", 
		"ENDDEVICE", 
		"INT", 
		"FLOAT", 
		"IF", 
		"THEN", 
		"ELSE", 
		"FOR", 
		"WHILE", 
		"WAIT", 
		"GO", 
		"ENDPRESSURE", 
		"VAR", 
		"BREAKPOINT", 
		"DEFUN", 
		"WS", 
		"NEWLINE", 
		"LINECOMMENT", 
		"ID", 
		"OBRACKET", 
		"CBRACKET", 
		"CURLYOBRACKET", 
		"CURLYCBRACKET", 
		"EQUALS", 
		"DOT", 
		"SEMI", 
		"COLON", 
		"COMMA"
    };

    public const int OpIncDec = 40;
    public const int WHILE = 60;
    public const int OpLogicalA = 45;
    public const int OBJECTNAME = 25;
    public const int OpAnd = 47;
    public const int CPROGRAM = 4;
    public const int OpLogicalB = 46;
    public const int OpNegation = 41;
    public const int CTYPE = 6;
    public const int DBOOL = 50;
    public const int FOR = 59;
    public const int PARAM = 38;
    public const int FLOAT = 55;
    public const int EQUALS = 75;
    public const int OpAddSub = 44;
    public const int CURLYCBRACKET = 74;
    public const int LINECOMMENT = 69;
    public const int ID = 70;
    public const int EOF = -1;
    public const int CASYNCCALL = 21;
    public const int CSYNCFUNCCALL = 34;
    public const int IF = 56;
    public const int TYPE = 49;
    public const int CIFTE = 9;
    public const int CWAITANYCALL = 23;
    public const int CWAITFUNCFINISH = 35;
    public const int THEN = 57;
    public const int CFORDEC = 13;
    public const int COMMA = 79;
    public const int OpDivMul = 43;
    public const int CDEVICE = 5;
    public const int CURLYOBRACKET = 73;
    public const int CSYNCCALL = 20;
    public const int CFOR = 12;
    public const int DEVICE = 51;
    public const int NODES = 27;
    public const int VAR = 64;
    public const int CREGFUNCACCESS = 31;
    public const int ENDDEVICE = 53;
    public const int DOT = 76;
    public const int CMETHODNAME = 15;
    public const int CBRACKET = 72;
    public const int PARAMS = 37;
    public const int MEMBERNAME = 26;
    public const int CWHILE = 11;
    public const int STATE = 52;
    public const int DEFUN = 66;
    public const int OpUnar = 42;
    public const int CTERMINATEALL = 32;
    public const int CREGMETHACCESS = 30;
    public const int ELSE = 58;
    public const int CDEFUN = 36;
    public const int CSTATEMENT = 8;
    public const int CUNARMIN = 14;
    public const int INT = 54;
    public const int WAIT = 61;
    public const int SEMI = 77;
    public const int CASSIGN = 10;
    public const int COLON = 78;
    public const int CBREAKPOINT = 29;
    public const int CINT = 17;
    public const int WS = 67;
    public const int TERMINATEALL = 39;
    public const int CENDTHECALL = 24;
    public const int NEWLINE = 68;
    public const int OpOr = 48;
    public const int ENDPRESSURE = 63;
    public const int CBLOCK = 7;
    public const int CCALL = 16;
    public const int CASYNCFUNCCALL = 33;
    public const int CGETSTATE = 28;
    public const int GO = 62;
    public const int OBRACKET = 71;
    public const int CBOOL = 19;
    public const int CFLOAT = 18;
    public const int BREAKPOINT = 65;
    public const int CWAITTHECALL = 22;

    // delegates
    // delegators



        public cLPMEDIntelliSenseParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public cLPMEDIntelliSenseParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return cLPMEDIntelliSenseParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "cLPMEDIntelliSenseParser.g"; }
    }


    	public List<Exception> Logger = new List<Exception>();
    	
    	private int cursorLocationX = -1;
    	private int cursorLocationY = -1;
    	public string ContextType = "Clear";
    	public List<IToken> Domain = new List<IToken>();

    	private void SetContext(string context, IToken main, IList children, IToken last)
        {
            Func<IToken, bool> beforeCursor = (domain) =>
                (domain.Line < cursorLocationY)
                || ((domain.Line == cursorLocationY) && (domain.CharPositionInLine < cursorLocationX));

            if (beforeCursor(main))
            {
                ContextType = context;
                Domain.Clear();
                Domain.Add(main);
              
                var domainsToAdd = new List<IToken>();
                if (children != null)
                    domainsToAdd.AddRange(children.Cast<IToken>());
                if (last != null)        
                    domainsToAdd.Add(last);
              
                Domain.AddRange(from domain in domainsToAdd
                                where beforeCursor(domain)
                                select domain);
            }
        }
        private void ResetContext(IToken anyToken)
        {
            if ((anyToken.CharPositionInLine < cursorLocationX) && (anyToken.Line <= cursorLocationY))
            {
                ContextType = "Clear";
                Domain.Clear();
            }
        }


    public class program_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "program"
    // cLPMEDIntelliSenseParser.g:58:1: program[int cursorLocationX, int cursorLocationY] options {backtrack=false; } : ( atom )+ ;
    public cLPMEDIntelliSenseParser.program_return program(int cursorLocationX, int cursorLocationY) // throws RecognitionException [1]
    {   
        cLPMEDIntelliSenseParser.program_return retval = new cLPMEDIntelliSenseParser.program_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        cLPMEDIntelliSenseParser.atom_return atom1 = default(cLPMEDIntelliSenseParser.atom_return);




        	this.cursorLocationX = cursorLocationX;
        	this.cursorLocationY = cursorLocationY;

        try 
    	{
            // cLPMEDIntelliSenseParser.g:68:1: ( ( atom )+ )
            // cLPMEDIntelliSenseParser.g:69:3: ( atom )+
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// cLPMEDIntelliSenseParser.g:69:3: ( atom )+
            	int cnt1 = 0;
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);

            	    if ( ((LA1_0 >= TERMINATEALL && LA1_0 <= OpOr) || (LA1_0 >= INT && LA1_0 <= FLOAT) || LA1_0 == WS || (LA1_0 >= LINECOMMENT && LA1_0 <= COMMA)) )
            	    {
            	        alt1 = 1;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // cLPMEDIntelliSenseParser.g:69:3: atom
            			    {
            			    	PushFollow(FOLLOW_atom_in_program86);
            			    	atom1 = atom();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, atom1.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt1 >= 1 ) goto loop1;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(1, input);
            		            throw eee;
            	    }
            	    cnt1++;
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whinging that label 'loop1' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "program"

    public class atom_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "atom"
    // cLPMEDIntelliSenseParser.g:72:1: atom options {backtrack=false; } : ( newID | allChildren | trash );
    public cLPMEDIntelliSenseParser.atom_return atom() // throws RecognitionException [1]
    {   
        cLPMEDIntelliSenseParser.atom_return retval = new cLPMEDIntelliSenseParser.atom_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        cLPMEDIntelliSenseParser.newID_return newID2 = default(cLPMEDIntelliSenseParser.newID_return);

        cLPMEDIntelliSenseParser.allChildren_return allChildren3 = default(cLPMEDIntelliSenseParser.allChildren_return);

        cLPMEDIntelliSenseParser.trash_return trash4 = default(cLPMEDIntelliSenseParser.trash_return);



        try 
    	{
            // cLPMEDIntelliSenseParser.g:77:1: ( newID | allChildren | trash )
            int alt2 = 3;
            int LA2_0 = input.LA(1);

            if ( (LA2_0 == ID) )
            {
                int LA2_1 = input.LA(2);

                if ( (LA2_1 == DOT) )
                {
                    switch ( input.LA(3) ) 
                    {
                    case ID:
                    	{
                        alt2 = 1;
                        }
                        break;
                    case EOF:
                    case TERMINATEALL:
                    case OpIncDec:
                    case OpNegation:
                    case OpUnar:
                    case OpDivMul:
                    case OpAddSub:
                    case OpLogicalA:
                    case OpLogicalB:
                    case OpAnd:
                    case OpOr:
                    case INT:
                    case FLOAT:
                    case WS:
                    case LINECOMMENT:
                    case OBRACKET:
                    case CBRACKET:
                    case CURLYOBRACKET:
                    case CURLYCBRACKET:
                    case EQUALS:
                    case SEMI:
                    case COLON:
                    case COMMA:
                    	{
                        alt2 = 2;
                        }
                        break;
                    case DOT:
                    	{
                        alt2 = 1;
                        }
                        break;
                    	default:
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    NoViableAltException nvae_d2s3 =
                    	        new NoViableAltException("", 2, 3, input);

                    	    throw nvae_d2s3;
                    }

                }
                else if ( (LA2_1 == EOF || (LA2_1 >= TERMINATEALL && LA2_1 <= OpOr) || (LA2_1 >= INT && LA2_1 <= FLOAT) || LA2_1 == WS || (LA2_1 >= LINECOMMENT && LA2_1 <= EQUALS) || (LA2_1 >= SEMI && LA2_1 <= COMMA)) )
                {
                    alt2 = 1;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d2s1 =
                        new NoViableAltException("", 2, 1, input);

                    throw nvae_d2s1;
                }
            }
            else if ( ((LA2_0 >= TERMINATEALL && LA2_0 <= OpOr) || (LA2_0 >= INT && LA2_0 <= FLOAT) || LA2_0 == WS || LA2_0 == LINECOMMENT || (LA2_0 >= OBRACKET && LA2_0 <= COMMA)) )
            {
                alt2 = 3;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d2s0 =
                    new NoViableAltException("", 2, 0, input);

                throw nvae_d2s0;
            }
            switch (alt2) 
            {
                case 1 :
                    // cLPMEDIntelliSenseParser.g:78:9: newID
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_newID_in_atom117);
                    	newID2 = newID();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, newID2.Tree);

                    }
                    break;
                case 2 :
                    // cLPMEDIntelliSenseParser.g:79:9: allChildren
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_allChildren_in_atom127);
                    	allChildren3 = allChildren();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, allChildren3.Tree);

                    }
                    break;
                case 3 :
                    // cLPMEDIntelliSenseParser.g:80:9: trash
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_trash_in_atom137);
                    	trash4 = trash();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, trash4.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "atom"

    public class newID_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "newID"
    // cLPMEDIntelliSenseParser.g:83:1: newID options {backtrack=true; } : main= ID ( DOT children+= ID )* ;
    public cLPMEDIntelliSenseParser.newID_return newID() // throws RecognitionException [1]
    {   
        cLPMEDIntelliSenseParser.newID_return retval = new cLPMEDIntelliSenseParser.newID_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken main = null;
        IToken DOT5 = null;
        IToken children = null;
        IList list_children = null;

        CommonTree main_tree=null;
        CommonTree DOT5_tree=null;
        CommonTree children_tree=null;

        try 
    	{
            // cLPMEDIntelliSenseParser.g:88:1: (main= ID ( DOT children+= ID )* )
            // cLPMEDIntelliSenseParser.g:89:5: main= ID ( DOT children+= ID )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	main=(IToken)Match(input,ID,FOLLOW_ID_in_newID169); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{main_tree = (CommonTree)adaptor.Create(main);
            		adaptor.AddChild(root_0, main_tree);
            	}
            	// cLPMEDIntelliSenseParser.g:89:15: ( DOT children+= ID )*
            	do 
            	{
            	    int alt3 = 2;
            	    int LA3_0 = input.LA(1);

            	    if ( (LA3_0 == DOT) )
            	    {
            	        int LA3_2 = input.LA(2);

            	        if ( (LA3_2 == ID) )
            	        {
            	            alt3 = 1;
            	        }


            	    }


            	    switch (alt3) 
            		{
            			case 1 :
            			    // cLPMEDIntelliSenseParser.g:89:16: DOT children+= ID
            			    {
            			    	DOT5=(IToken)Match(input,DOT,FOLLOW_DOT_in_newID172); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{DOT5_tree = (CommonTree)adaptor.Create(DOT5);
            			    		adaptor.AddChild(root_0, DOT5_tree);
            			    	}
            			    	children=(IToken)Match(input,ID,FOLLOW_ID_in_newID178); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{children_tree = (CommonTree)adaptor.Create(children);
            			    		adaptor.AddChild(root_0, children_tree);
            			    	}
            			    	if (list_children == null) list_children = new ArrayList();
            			    	list_children.Add(children);


            			    }
            			    break;

            			default:
            			    goto loop3;
            	    }
            	} while (true);

            	loop3:
            		;	// Stops C# compiler whining that label 'loop3' has no statements

            	if ( state.backtracking == 0 ) 
            	{

            	              var currentToken = this.TokenStream.Get(((list_children != null) && (list_children.Count > 0)) ? 
            	                  (list_children[list_children.Count - 1] as IToken).TokenIndex
            	                  : main.TokenIndex);
            	              if (currentToken.TokenIndex < this.TokenStream.Size() - 1)
            	              {
            	                  var nextToken = this.TokenStream.Get(currentToken.TokenIndex + 1);
            	                  
            	                  switch (nextToken.Type)
            	                  {
            	                      case 67: //if after current goes WhiteSpace
            	                          ResetContext(currentToken);
            	                          break;
            	                      case 76: //if after current goes DOT
            	                          SetContext("AllChildren", main, list_children, null);
            	                          break;
            	                      default: //else it's continuing of current dotted name
            	                          SetContext("NewID", main, list_children, null);
            	                          break;
            	                  }
            	              }
            	              else
            	                  SetContext("NewID", main, list_children, null);
            	          
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "newID"

    public class allChildren_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "allChildren"
    // cLPMEDIntelliSenseParser.g:116:1: allChildren options {backtrack=true; } : (children+= ID DOT )+ ;
    public cLPMEDIntelliSenseParser.allChildren_return allChildren() // throws RecognitionException [1]
    {   
        cLPMEDIntelliSenseParser.allChildren_return retval = new cLPMEDIntelliSenseParser.allChildren_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken DOT6 = null;
        IToken children = null;
        IList list_children = null;

        CommonTree DOT6_tree=null;
        CommonTree children_tree=null;

        try 
    	{
            // cLPMEDIntelliSenseParser.g:121:1: ( (children+= ID DOT )+ )
            // cLPMEDIntelliSenseParser.g:122:5: (children+= ID DOT )+
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// cLPMEDIntelliSenseParser.g:122:5: (children+= ID DOT )+
            	int cnt4 = 0;
            	do 
            	{
            	    int alt4 = 2;
            	    int LA4_0 = input.LA(1);

            	    if ( (LA4_0 == ID) )
            	    {
            	        alt4 = 1;
            	    }


            	    switch (alt4) 
            		{
            			case 1 :
            			    // cLPMEDIntelliSenseParser.g:122:6: children+= ID DOT
            			    {
            			    	children=(IToken)Match(input,ID,FOLLOW_ID_in_allChildren224); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{children_tree = (CommonTree)adaptor.Create(children);
            			    		adaptor.AddChild(root_0, children_tree);
            			    	}
            			    	if (list_children == null) list_children = new ArrayList();
            			    	list_children.Add(children);

            			    	DOT6=(IToken)Match(input,DOT,FOLLOW_DOT_in_allChildren226); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{DOT6_tree = (CommonTree)adaptor.Create(DOT6);
            			    		adaptor.AddChild(root_0, DOT6_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt4 >= 1 ) goto loop4;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(4, input);
            		            throw eee;
            	    }
            	    cnt4++;
            	} while (true);

            	loop4:
            		;	// Stops C# compiler whinging that label 'loop4' has no statements

            	if ( state.backtracking == 0 ) 
            	{

            	              var idfirstName = list_children[0] as IToken;
            	              list_children.Remove(idfirstName);
            	              SetContext("AllChildren", idfirstName, list_children, null);
            	          
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "allChildren"

    public class trash_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "trash"
    // cLPMEDIntelliSenseParser.g:130:1: trash options {backtrack=true; } : ( TERMINATEALL | OpIncDec | OpNegation | OpUnar | OpDivMul | OpAddSub | OpLogicalA | OpLogicalB | OpAnd | OpOr | INT | FLOAT | WS | LINECOMMENT | OBRACKET | CBRACKET | CURLYOBRACKET | CURLYCBRACKET | EQUALS | first= EQUALS EQUALS | SEMI | COLON | COMMA | dot= DOT ( DOT )+ );
    public cLPMEDIntelliSenseParser.trash_return trash() // throws RecognitionException [1]
    {   
        cLPMEDIntelliSenseParser.trash_return retval = new cLPMEDIntelliSenseParser.trash_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken first = null;
        IToken dot = null;
        IToken TERMINATEALL7 = null;
        IToken OpIncDec8 = null;
        IToken OpNegation9 = null;
        IToken OpUnar10 = null;
        IToken OpDivMul11 = null;
        IToken OpAddSub12 = null;
        IToken OpLogicalA13 = null;
        IToken OpLogicalB14 = null;
        IToken OpAnd15 = null;
        IToken OpOr16 = null;
        IToken INT17 = null;
        IToken FLOAT18 = null;
        IToken WS19 = null;
        IToken LINECOMMENT20 = null;
        IToken OBRACKET21 = null;
        IToken CBRACKET22 = null;
        IToken CURLYOBRACKET23 = null;
        IToken CURLYCBRACKET24 = null;
        IToken EQUALS25 = null;
        IToken EQUALS26 = null;
        IToken SEMI27 = null;
        IToken COLON28 = null;
        IToken COMMA29 = null;
        IToken DOT30 = null;

        CommonTree first_tree=null;
        CommonTree dot_tree=null;
        CommonTree TERMINATEALL7_tree=null;
        CommonTree OpIncDec8_tree=null;
        CommonTree OpNegation9_tree=null;
        CommonTree OpUnar10_tree=null;
        CommonTree OpDivMul11_tree=null;
        CommonTree OpAddSub12_tree=null;
        CommonTree OpLogicalA13_tree=null;
        CommonTree OpLogicalB14_tree=null;
        CommonTree OpAnd15_tree=null;
        CommonTree OpOr16_tree=null;
        CommonTree INT17_tree=null;
        CommonTree FLOAT18_tree=null;
        CommonTree WS19_tree=null;
        CommonTree LINECOMMENT20_tree=null;
        CommonTree OBRACKET21_tree=null;
        CommonTree CBRACKET22_tree=null;
        CommonTree CURLYOBRACKET23_tree=null;
        CommonTree CURLYCBRACKET24_tree=null;
        CommonTree EQUALS25_tree=null;
        CommonTree EQUALS26_tree=null;
        CommonTree SEMI27_tree=null;
        CommonTree COLON28_tree=null;
        CommonTree COMMA29_tree=null;
        CommonTree DOT30_tree=null;

        try 
    	{
            // cLPMEDIntelliSenseParser.g:135:1: ( TERMINATEALL | OpIncDec | OpNegation | OpUnar | OpDivMul | OpAddSub | OpLogicalA | OpLogicalB | OpAnd | OpOr | INT | FLOAT | WS | LINECOMMENT | OBRACKET | CBRACKET | CURLYOBRACKET | CURLYCBRACKET | EQUALS | first= EQUALS EQUALS | SEMI | COLON | COMMA | dot= DOT ( DOT )+ )
            int alt6 = 24;
            alt6 = dfa6.Predict(input);
            switch (alt6) 
            {
                case 1 :
                    // cLPMEDIntelliSenseParser.g:136:9: TERMINATEALL
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	TERMINATEALL7=(IToken)Match(input,TERMINATEALL,FOLLOW_TERMINATEALL_in_trash270); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{TERMINATEALL7_tree = (CommonTree)adaptor.Create(TERMINATEALL7);
                    		adaptor.AddChild(root_0, TERMINATEALL7_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(TERMINATEALL7);
                    	}

                    }
                    break;
                case 2 :
                    // cLPMEDIntelliSenseParser.g:137:9: OpIncDec
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OpIncDec8=(IToken)Match(input,OpIncDec,FOLLOW_OpIncDec_in_trash282); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OpIncDec8_tree = (CommonTree)adaptor.Create(OpIncDec8);
                    		adaptor.AddChild(root_0, OpIncDec8_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OpIncDec8);
                    	}

                    }
                    break;
                case 3 :
                    // cLPMEDIntelliSenseParser.g:138:9: OpNegation
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OpNegation9=(IToken)Match(input,OpNegation,FOLLOW_OpNegation_in_trash294); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OpNegation9_tree = (CommonTree)adaptor.Create(OpNegation9);
                    		adaptor.AddChild(root_0, OpNegation9_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OpNegation9);
                    	}

                    }
                    break;
                case 4 :
                    // cLPMEDIntelliSenseParser.g:139:9: OpUnar
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OpUnar10=(IToken)Match(input,OpUnar,FOLLOW_OpUnar_in_trash306); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OpUnar10_tree = (CommonTree)adaptor.Create(OpUnar10);
                    		adaptor.AddChild(root_0, OpUnar10_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OpUnar10);
                    	}

                    }
                    break;
                case 5 :
                    // cLPMEDIntelliSenseParser.g:140:9: OpDivMul
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OpDivMul11=(IToken)Match(input,OpDivMul,FOLLOW_OpDivMul_in_trash318); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OpDivMul11_tree = (CommonTree)adaptor.Create(OpDivMul11);
                    		adaptor.AddChild(root_0, OpDivMul11_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OpDivMul11);
                    	}

                    }
                    break;
                case 6 :
                    // cLPMEDIntelliSenseParser.g:141:9: OpAddSub
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OpAddSub12=(IToken)Match(input,OpAddSub,FOLLOW_OpAddSub_in_trash330); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OpAddSub12_tree = (CommonTree)adaptor.Create(OpAddSub12);
                    		adaptor.AddChild(root_0, OpAddSub12_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OpAddSub12);
                    	}

                    }
                    break;
                case 7 :
                    // cLPMEDIntelliSenseParser.g:142:9: OpLogicalA
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OpLogicalA13=(IToken)Match(input,OpLogicalA,FOLLOW_OpLogicalA_in_trash342); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OpLogicalA13_tree = (CommonTree)adaptor.Create(OpLogicalA13);
                    		adaptor.AddChild(root_0, OpLogicalA13_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OpLogicalA13);
                    	}

                    }
                    break;
                case 8 :
                    // cLPMEDIntelliSenseParser.g:143:9: OpLogicalB
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OpLogicalB14=(IToken)Match(input,OpLogicalB,FOLLOW_OpLogicalB_in_trash354); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OpLogicalB14_tree = (CommonTree)adaptor.Create(OpLogicalB14);
                    		adaptor.AddChild(root_0, OpLogicalB14_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OpLogicalB14);
                    	}

                    }
                    break;
                case 9 :
                    // cLPMEDIntelliSenseParser.g:144:9: OpAnd
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OpAnd15=(IToken)Match(input,OpAnd,FOLLOW_OpAnd_in_trash366); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OpAnd15_tree = (CommonTree)adaptor.Create(OpAnd15);
                    		adaptor.AddChild(root_0, OpAnd15_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OpAnd15);
                    	}

                    }
                    break;
                case 10 :
                    // cLPMEDIntelliSenseParser.g:145:9: OpOr
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OpOr16=(IToken)Match(input,OpOr,FOLLOW_OpOr_in_trash378); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OpOr16_tree = (CommonTree)adaptor.Create(OpOr16);
                    		adaptor.AddChild(root_0, OpOr16_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OpOr16);
                    	}

                    }
                    break;
                case 11 :
                    // cLPMEDIntelliSenseParser.g:146:9: INT
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	INT17=(IToken)Match(input,INT,FOLLOW_INT_in_trash390); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{INT17_tree = (CommonTree)adaptor.Create(INT17);
                    		adaptor.AddChild(root_0, INT17_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(INT17);
                    	}

                    }
                    break;
                case 12 :
                    // cLPMEDIntelliSenseParser.g:147:9: FLOAT
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	FLOAT18=(IToken)Match(input,FLOAT,FOLLOW_FLOAT_in_trash402); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{FLOAT18_tree = (CommonTree)adaptor.Create(FLOAT18);
                    		adaptor.AddChild(root_0, FLOAT18_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(FLOAT18);
                    	}

                    }
                    break;
                case 13 :
                    // cLPMEDIntelliSenseParser.g:148:9: WS
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	WS19=(IToken)Match(input,WS,FOLLOW_WS_in_trash414); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{WS19_tree = (CommonTree)adaptor.Create(WS19);
                    		adaptor.AddChild(root_0, WS19_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(WS19);
                    	}

                    }
                    break;
                case 14 :
                    // cLPMEDIntelliSenseParser.g:149:9: LINECOMMENT
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	LINECOMMENT20=(IToken)Match(input,LINECOMMENT,FOLLOW_LINECOMMENT_in_trash426); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{LINECOMMENT20_tree = (CommonTree)adaptor.Create(LINECOMMENT20);
                    		adaptor.AddChild(root_0, LINECOMMENT20_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(LINECOMMENT20);
                    	}

                    }
                    break;
                case 15 :
                    // cLPMEDIntelliSenseParser.g:150:9: OBRACKET
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	OBRACKET21=(IToken)Match(input,OBRACKET,FOLLOW_OBRACKET_in_trash438); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{OBRACKET21_tree = (CommonTree)adaptor.Create(OBRACKET21);
                    		adaptor.AddChild(root_0, OBRACKET21_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(OBRACKET21);
                    	}

                    }
                    break;
                case 16 :
                    // cLPMEDIntelliSenseParser.g:151:9: CBRACKET
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	CBRACKET22=(IToken)Match(input,CBRACKET,FOLLOW_CBRACKET_in_trash450); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{CBRACKET22_tree = (CommonTree)adaptor.Create(CBRACKET22);
                    		adaptor.AddChild(root_0, CBRACKET22_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(CBRACKET22);
                    	}

                    }
                    break;
                case 17 :
                    // cLPMEDIntelliSenseParser.g:152:9: CURLYOBRACKET
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	CURLYOBRACKET23=(IToken)Match(input,CURLYOBRACKET,FOLLOW_CURLYOBRACKET_in_trash462); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{CURLYOBRACKET23_tree = (CommonTree)adaptor.Create(CURLYOBRACKET23);
                    		adaptor.AddChild(root_0, CURLYOBRACKET23_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(CURLYOBRACKET23);
                    	}

                    }
                    break;
                case 18 :
                    // cLPMEDIntelliSenseParser.g:153:9: CURLYCBRACKET
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	CURLYCBRACKET24=(IToken)Match(input,CURLYCBRACKET,FOLLOW_CURLYCBRACKET_in_trash474); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{CURLYCBRACKET24_tree = (CommonTree)adaptor.Create(CURLYCBRACKET24);
                    		adaptor.AddChild(root_0, CURLYCBRACKET24_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(CURLYCBRACKET24);
                    	}

                    }
                    break;
                case 19 :
                    // cLPMEDIntelliSenseParser.g:154:9: EQUALS
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	EQUALS25=(IToken)Match(input,EQUALS,FOLLOW_EQUALS_in_trash486); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{EQUALS25_tree = (CommonTree)adaptor.Create(EQUALS25);
                    		adaptor.AddChild(root_0, EQUALS25_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(EQUALS25);
                    	}

                    }
                    break;
                case 20 :
                    // cLPMEDIntelliSenseParser.g:155:9: first= EQUALS EQUALS
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	first=(IToken)Match(input,EQUALS,FOLLOW_EQUALS_in_trash502); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{first_tree = (CommonTree)adaptor.Create(first);
                    		adaptor.AddChild(root_0, first_tree);
                    	}
                    	EQUALS26=(IToken)Match(input,EQUALS,FOLLOW_EQUALS_in_trash504); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{EQUALS26_tree = (CommonTree)adaptor.Create(EQUALS26);
                    		adaptor.AddChild(root_0, EQUALS26_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(first);
                    	}

                    }
                    break;
                case 21 :
                    // cLPMEDIntelliSenseParser.g:156:9: SEMI
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	SEMI27=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_trash518); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{SEMI27_tree = (CommonTree)adaptor.Create(SEMI27);
                    		adaptor.AddChild(root_0, SEMI27_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(SEMI27);
                    	}

                    }
                    break;
                case 22 :
                    // cLPMEDIntelliSenseParser.g:157:9: COLON
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	COLON28=(IToken)Match(input,COLON,FOLLOW_COLON_in_trash530); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{COLON28_tree = (CommonTree)adaptor.Create(COLON28);
                    		adaptor.AddChild(root_0, COLON28_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(COLON28);
                    	}

                    }
                    break;
                case 23 :
                    // cLPMEDIntelliSenseParser.g:158:9: COMMA
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	COMMA29=(IToken)Match(input,COMMA,FOLLOW_COMMA_in_trash542); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{COMMA29_tree = (CommonTree)adaptor.Create(COMMA29);
                    		adaptor.AddChild(root_0, COMMA29_tree);
                    	}
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(COMMA29);
                    	}

                    }
                    break;
                case 24 :
                    // cLPMEDIntelliSenseParser.g:159:9: dot= DOT ( DOT )+
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	dot=(IToken)Match(input,DOT,FOLLOW_DOT_in_trash558); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{dot_tree = (CommonTree)adaptor.Create(dot);
                    		adaptor.AddChild(root_0, dot_tree);
                    	}
                    	// cLPMEDIntelliSenseParser.g:159:19: ( DOT )+
                    	int cnt5 = 0;
                    	do 
                    	{
                    	    int alt5 = 2;
                    	    int LA5_0 = input.LA(1);

                    	    if ( (LA5_0 == DOT) )
                    	    {
                    	        alt5 = 1;
                    	    }


                    	    switch (alt5) 
                    		{
                    			case 1 :
                    			    // cLPMEDIntelliSenseParser.g:159:20: DOT
                    			    {
                    			    	DOT30=(IToken)Match(input,DOT,FOLLOW_DOT_in_trash561); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{DOT30_tree = (CommonTree)adaptor.Create(DOT30);
                    			    		adaptor.AddChild(root_0, DOT30_tree);
                    			    	}

                    			    }
                    			    break;

                    			default:
                    			    if ( cnt5 >= 1 ) goto loop5;
                    			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    		            EarlyExitException eee =
                    		                new EarlyExitException(5, input);
                    		            throw eee;
                    	    }
                    	    cnt5++;
                    	} while (true);

                    	loop5:
                    		;	// Stops C# compiler whinging that label 'loop5' has no statements

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  ResetContext(dot);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "trash"

    // $ANTLR start "synpred19_cLPMEDIntelliSenseParser"
    public void synpred19_cLPMEDIntelliSenseParser_fragment() {
        // cLPMEDIntelliSenseParser.g:154:9: ( EQUALS )
        // cLPMEDIntelliSenseParser.g:154:9: EQUALS
        {
        	Match(input,EQUALS,FOLLOW_EQUALS_in_synpred19_cLPMEDIntelliSenseParser486); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred19_cLPMEDIntelliSenseParser"

    // $ANTLR start "synpred20_cLPMEDIntelliSenseParser"
    public void synpred20_cLPMEDIntelliSenseParser_fragment() {
        IToken first = null;

        // cLPMEDIntelliSenseParser.g:155:9: (first= EQUALS EQUALS )
        // cLPMEDIntelliSenseParser.g:155:9: first= EQUALS EQUALS
        {
        	first=(IToken)Match(input,EQUALS,FOLLOW_EQUALS_in_synpred20_cLPMEDIntelliSenseParser502); if (state.failed) return ;
        	Match(input,EQUALS,FOLLOW_EQUALS_in_synpred20_cLPMEDIntelliSenseParser504); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred20_cLPMEDIntelliSenseParser"

    // Delegated rules

   	public bool synpred19_cLPMEDIntelliSenseParser() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred19_cLPMEDIntelliSenseParser_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred20_cLPMEDIntelliSenseParser() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred20_cLPMEDIntelliSenseParser_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}


   	protected DFA6 dfa6;
	private void InitializeCyclicDFAs()
	{
    	this.dfa6 = new DFA6(this);
	    this.dfa6.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA6_SpecialStateTransition);
	}

    const string DFA6_eotS =
        "\x1b\uffff";
    const string DFA6_eofS =
        "\x13\uffff\x01\x19\x07\uffff";
    const string DFA6_minS =
        "\x01\x27\x12\uffff\x01\x27\x04\uffff\x01\x00\x02\uffff";
    const string DFA6_maxS =
        "\x01\x4f\x12\uffff\x01\x4f\x04\uffff\x01\x00\x02\uffff";
    const string DFA6_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\x06\x01"+
        "\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01"+
        "\x0f\x01\x10\x01\x11\x01\x12\x01\uffff\x01\x15\x01\x16\x01\x17\x01"+
        "\x18\x01\uffff\x01\x13\x01\x14";
    const string DFA6_specialS =
        "\x18\uffff\x01\x00\x02\uffff}>";
    static readonly string[] DFA6_transitionS = {
            "\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01"+
            "\x08\x01\x09\x01\x0a\x05\uffff\x01\x0b\x01\x0c\x0b\uffff\x01"+
            "\x0d\x01\uffff\x01\x0e\x01\uffff\x01\x0f\x01\x10\x01\x11\x01"+
            "\x12\x01\x13\x01\x17\x01\x14\x01\x15\x01\x16",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x0a\x19\x05\uffff\x02\x19\x0b\uffff\x01\x19\x01\uffff\x06"+
            "\x19\x01\x18\x04\x19",
            "",
            "",
            "",
            "",
            "\x01\uffff",
            "",
            ""
    };

    static readonly short[] DFA6_eot = DFA.UnpackEncodedString(DFA6_eotS);
    static readonly short[] DFA6_eof = DFA.UnpackEncodedString(DFA6_eofS);
    static readonly char[] DFA6_min = DFA.UnpackEncodedStringToUnsignedChars(DFA6_minS);
    static readonly char[] DFA6_max = DFA.UnpackEncodedStringToUnsignedChars(DFA6_maxS);
    static readonly short[] DFA6_accept = DFA.UnpackEncodedString(DFA6_acceptS);
    static readonly short[] DFA6_special = DFA.UnpackEncodedString(DFA6_specialS);
    static readonly short[][] DFA6_transition = DFA.UnpackEncodedStringArray(DFA6_transitionS);

    protected class DFA6 : DFA
    {
        public DFA6(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 6;
            this.eot = DFA6_eot;
            this.eof = DFA6_eof;
            this.min = DFA6_min;
            this.max = DFA6_max;
            this.accept = DFA6_accept;
            this.special = DFA6_special;
            this.transition = DFA6_transition;

        }

        override public string Description
        {
            get { return "130:1: trash options {backtrack=true; } : ( TERMINATEALL | OpIncDec | OpNegation | OpUnar | OpDivMul | OpAddSub | OpLogicalA | OpLogicalB | OpAnd | OpOr | INT | FLOAT | WS | LINECOMMENT | OBRACKET | CBRACKET | CURLYOBRACKET | CURLYCBRACKET | EQUALS | first= EQUALS EQUALS | SEMI | COLON | COMMA | dot= DOT ( DOT )+ );"; }
        }

    }


    protected internal int DFA6_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA6_24 = input.LA(1);

                   	 
                   	int index6_24 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cLPMEDIntelliSenseParser()) ) { s = 25; }

                   	else if ( (synpred20_cLPMEDIntelliSenseParser()) ) { s = 26; }

                   	 
                   	input.Seek(index6_24);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 6, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
 

    public static readonly BitSet FOLLOW_atom_in_program86 = new BitSet(new ulong[]{0x00C1FF8000000002UL,0x000000000000FFE8UL});
    public static readonly BitSet FOLLOW_newID_in_atom117 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_allChildren_in_atom127 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_trash_in_atom137 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_newID169 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_DOT_in_newID172 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_newID178 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_ID_in_allChildren224 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_DOT_in_allChildren226 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_TERMINATEALL_in_trash270 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OpIncDec_in_trash282 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OpNegation_in_trash294 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OpUnar_in_trash306 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OpDivMul_in_trash318 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OpAddSub_in_trash330 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OpLogicalA_in_trash342 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OpLogicalB_in_trash354 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OpAnd_in_trash366 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OpOr_in_trash378 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_INT_in_trash390 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FLOAT_in_trash402 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WS_in_trash414 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LINECOMMENT_in_trash426 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OBRACKET_in_trash438 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CBRACKET_in_trash450 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CURLYOBRACKET_in_trash462 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CURLYCBRACKET_in_trash474 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_EQUALS_in_trash486 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_EQUALS_in_trash502 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_EQUALS_in_trash504 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_SEMI_in_trash518 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_COLON_in_trash530 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_COMMA_in_trash542 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DOT_in_trash558 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_DOT_in_trash561 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_EQUALS_in_synpred19_cLPMEDIntelliSenseParser486 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_EQUALS_in_synpred20_cLPMEDIntelliSenseParser502 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_EQUALS_in_synpred20_cLPMEDIntelliSenseParser504 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}